computer notes - Data Structures - 17

Class No.17 Data Structures http://ecomputernotes.com

Reference Variables The symbol “&” has a few different purposes depending on where it occurs in code. When it appears in front of a variable name, it is the address operator, i.e., it returns the address of the variable in memory. int x; int* ptr = &x; http://ecomputernotes.com

Reference Variables The symbol “&’ can also appear after a type in a function signature: For example, insert and remove from the BinarySearchTree class. void insert( const EType& x ); void remove( const EType& x ); http://ecomputernotes.com

Reference Variables Or, in case we designed the BinarySearchTree class to hold integers only, i.e., no templates void insert( const int& x ); void remove( const int& x ); http://ecomputernotes.com

Reference Variables The “&” indicates a parameter that is a reference variable . Consider the following three different functions: http://ecomputernotes.com

Reference Variables // example 1 int intMinus1( int oldVal) { oldVal = oldVal – 1; return oldVal; } http://ecomputernotes.com

Reference Variables // example 2 int intMinus2( int* oldVal) { *oldVal = *oldVal – 2; return *oldVal; } http://ecomputernotes.com

Reference Variables // example 3 int intMinus3( int& oldVal) { oldVal = oldVal – 3; return oldVal; } http://ecomputernotes.com

Reference Variables The caller function: calling intMinus1 void caller() { int myInt = 31; int retVal; retVal = intMinus1( myInt ); cout << myInt << retVal; } http://ecomputernotes.com

Memory Organization Code Static data Stack Heap Process 1 (browser) Process 3 (word) Process 4 (ourtest.exe) Windows OS Process 2 (dev-c++) http://ecomputernotes.com

Reference Variables Call stack layout Parameters(caller) Local variables(caller) Return address(caller) Parameters(intMinus1) Local variables(intMinus1) Return address(intMinus1) sp Stack grows downwards http://ecomputernotes.com

Reference Variables Call stack layout when intMinus1 is called: 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal 31 calling function “caller” called function “intMinus1” stack grows downwards sp

Reference Variables How are myInt and oldVal related? Passing myInt to the function intMinus1 results in a copy of myInt to be placed in parameter oldVal in the call stack. Alterations are done to the copy of “31” (stored in oldVal) and not the original myInt. http://ecomputernotes.com

Reference Variables The original myInt remains unchanged . For this reason, this technique of passing parameters is called pass by value . Alterations are done to the copy of “31” (stored in oldVal) and not the original myInt. http://ecomputernotes.com

Reference Variables Call stack layout after subtraction in intMinus1: 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal 31 calling function “caller” called function “intMinus1” stack grows downwards sp 30

Reference Variables Call stack layout after return from intMinus1: 1068 31 1072 30 caller’s other stuff myInt retVal calling function “caller” stack grows downwards sp

Reference Variables We could have called intMinus1 as void caller() { int retVal; retVal = intMinus1( 31 );// literal cout << myInt << retVal; } Because it is the value that is passed. We can always pass a literal or even an expression in call-by-value. http://ecomputernotes.com

Reference Variables If the programmer wanted to actually change a variable’s value from within a function, one way would be to send a pointer: void caller() { int retVal; int myInt = 31; retVal = intMinus2( &myInt ); cout << myInt << retVal; } Call this call-by-pointer. http://ecomputernotes.com

Reference Variables Call stack layout when intMinus2 is called: 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal 1072 calling function “caller” called function “intMinus2” stack grows downwards sp

Reference Variables Call stack layout after *oldVal = *oldVal – 2; 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal 1072 calling function “caller” called function “intMinus2” stack grows downwards sp 29

Reference Variables Call stack layout after return from intMinus2. 1068 31 1072 29 caller’s other stuff myInt retVal calling function “caller” stack grows downwards sp 29

Reference Variables Suppose we want a function to change an object. But we don’t want to send the function a copy. The object could be large and copying it costs time. We don’t want to use pointers because of the messy syntax. http://ecomputernotes.com

Reference Variables The answer: call-by-reference (or pass-by-reference): void caller() { int retVal; int myInt = 31; retVal = intMinus3( myInt ); cout << myInt << retVal; } http://ecomputernotes.com

Reference Variables The & after int means that oldVal is an integer reference variable. // example 3 int intMinus3( int& oldVal) { oldVal = oldVal – 3; return oldVal; } http://ecomputernotes.com

Reference Variables So what is a reference variable? The idea is: the integer object myInt is used exactly as it exists in the caller. The function simply reaches it through a different name , oldVal. The function intMinus3 cannot use the name myInt because it is in the caller’s scope. But both variable names refer to the same object (same memory cell). http://ecomputernotes.com

Reference Variables Call stack layout when intMinus3 is called: 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal calling function “caller” called function “intMinus3” stack grows downwards sp

Reference Variables Call stack layout after oldVal = oldVal - 3: 1052 1060 1068 1056 31 1072 ? caller’s other stuff myInt retVal oldVal calling function “caller” called function “intMinus3” stack grows downwards sp 28

Reference Variables Call stack layout after return from intMinus3: 1068 31 1072 28 caller’s other stuff myInt retVal calling function “caller” stack grows downwards sp 28

Reference Variables The compiler may actually implement call-by-reference using pointers as we did in example 2. The obtaining of address and de-referencing would be done behind the scene. We should think in terms of the “renaming” abstraction. http://ecomputernotes.com

computer notes - Data Structures - 17

More Related Content

What's hot (19)

Viewers also liked (20)

Similar to computer notes - Data Structures - 17 (20)

More from ecomputernotes (20)

Recently uploaded (20)

computer notes - Data Structures - 17

Editor's Notes